﻿using DevExpress.XtraEditors;
using MesProjectWinform.BasicData.Entity;
using MesProjectWinform.Public.Common;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;

namespace MesProjectWinform.BasicData.基础实现.wuliao
{
    public partial class wuup : DevExpress.XtraEditors.XtraForm
    {
        private string apiBaseUrl = "http://localhost:5052";
        private long? materialId = null; // 如果是修改操作，存储物料ID
        private bool isEdit = false; // 标记当前是编辑还是新增操作
        private Materialgroupmodel originalMaterial = null; // 存储原始物料信息（编辑模式）
        // 序号存储文件路径
        private readonly string sequenceFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "MaterialSequence.txt");
        // 日期格式化字符串
        private readonly string dateFormat = "yyMMdd";

        public wuup()
        {
            InitializeComponent();
            InitMaterialTypeCombo();
            InitOperationalPathCombo();
            UpdatePathidVisibility(); // 初始状态设置
            
            // 设置编码文本框为只读
            textEdit1.Properties.ReadOnly = true;
            // 生成自动递增编码（仅在新增模式下）
            GenerateAutoIncrementCode();
            
            // 使用Settings中的BaseUrl
            apiBaseUrl = MesProjectWinform.Properties.Settings.Default.BaseUrl;
        }

        public wuup(long id) : this()
        {
            materialId = id;
            isEdit = true;
            LoadMaterialData(id);
        }

        /// <summary>
        /// 生成自动递增的物料编码
        /// </summary>
        private void GenerateAutoIncrementCode()
        {
            // 只有在新增模式下才生成自动编码
            if (isEdit)
                return;
                
            try
            {
                // 生成当前日期部分 格式：yyMMdd
                string today = DateTime.Now.ToString(dateFormat);
                
                // 读取序号文件，获取当前最大序号
                int currentSequence = 1; // 默认从1开始
                string lastDate = string.Empty;
                
                if (File.Exists(sequenceFilePath))
                {
                    string[] fileContent = File.ReadAllLines(sequenceFilePath);
                    if (fileContent.Length >= 2)
                    {
                        lastDate = fileContent[0]; // 第一行存储日期
                        int.TryParse(fileContent[1], out currentSequence); // 第二行存储序号
                        
                        // 如果是新的一天，重置序号为1
                        if (lastDate != today)
                        {
                            currentSequence = 1;
                        }
                        // 注意：此处不自增序号，只显示当前序号
                    }
                }
                
                // 格式化为4位数字，前面补0
                string serialPart = currentSequence.ToString().PadLeft(4, '0');
                
                // 组合最终的编码：WL + 日期 + 4位序号
                string finalCode = "WL" + today + serialPart;
                
                // 设置到文本框
                textEdit1.Text = finalCode;
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"生成物料编码时发生错误：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                // 生成失败时使用默认编码
                textEdit1.Text = "WL" + DateTime.Now.ToString(dateFormat) + "0001";
            }
        }

        private void wuup_Load(object sender, EventArgs e)
        {
            // 窗体加载时执行
            UpdatePathidVisibility();
        }

        private void InitMaterialTypeCombo()
        {
            comboBox1.Items.Clear();
            comboBox1.Items.Add("原材料");
            comboBox1.Items.Add("半成品");
            comboBox1.Items.Add("成品");
            comboBox1.Items.Add("工具");
            comboBox1.Items.Add("其他");
            comboBox1.SelectedIndex = 0;
        }

        private void InitOperationalPathCombo()
        {
            // 清空下拉框
            comboBoxPathid.Items.Clear();
            
            // 添加工艺路线选项
            comboBoxPathid.Items.Add("手工");
            comboBoxPathid.Items.Add("电路排查");
            comboBoxPathid.Items.Add("过滤检测");
            comboBoxPathid.Items.Add("后盖工艺");
            comboBoxPathid.Items.Add("组焊");
            comboBoxPathid.Items.Add("测试产品");

            // 设置默认选择
            if (comboBoxPathid.Items.Count > 0)
            {
                comboBoxPathid.SelectedIndex = 0;
            }
        }

        // 根据所选类型显示或隐藏工艺路线
        private void UpdatePathidVisibility()
        {
            // 获取当前选择的类型
            string selectedType = comboBox1.SelectedItem?.ToString();

            // 只在成品和半成品时显示工艺路线
            bool showPathid = (selectedType == "成品" || selectedType == "半成品");

            // 更新控件可见性
            labelControl4.Visible = showPathid;
            comboBoxPathid.Visible = showPathid;

            // 如果不需要显示，则将值设置为"-"
            if (!showPathid)
            {
                comboBoxPathid.SelectedIndex = -1; // 取消选择
            }
        }

        // 类型选择改变事件
        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            UpdatePathidVisibility();
        }

        // 加载物料数据
        private async void LoadMaterialData(long id)
        {
            try
            {
                // 构建请求URL
                string url = $"/api/Materialgroup/GetMaterialgroupById?id={id}";
                Console.WriteLine($"正在请求API: {url}");
                
                // 使用 HttpClientHelper 发送请求
                string result = await HttpClientHelper.RequestUrl(RequestType.Get, url, "");
                Console.WriteLine($"API返回结果: {result}");
                
                if (string.IsNullOrEmpty(result))
                {
                    XtraMessageBox.Show("获取物料信息失败！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    isEdit = false;
                    return;
                }
                
                // 尝试解析JSON
                Materialgroupmodel material = null;
                
                // 尝试方式1：直接解析为Materialgroupmodel对象
                try
                {
                    material = JsonConvert.DeserializeObject<Materialgroupmodel>(result);
                    if (material != null && material.Id > 0)
                    {
                        Console.WriteLine($"成功直接解析为物料对象，ID={material.Id}");
                    }
                    else
                    {
                        material = null; // 重置为null以尝试其他方式
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"直接解析为物料对象失败: {ex.Message}");
                }
                
                // 尝试方式2：解析为ApiResponse<Materialgroupmodel>格式
                if (material == null)
                {
                    try
                    {
                        // 尝试解析为常见的API响应格式
                        dynamic response = JsonConvert.DeserializeObject<dynamic>(result);
                        if (response.data != null)
                        {
                            // 从data字段获取物料数据
                            string materialJson = JsonConvert.SerializeObject(response.data);
                            material = JsonConvert.DeserializeObject<Materialgroupmodel>(materialJson);
                            Console.WriteLine($"从API响应的data字段成功解析物料数据，名称={material?.Materialgroupname}");
                        }
                        else if (response.Data != null)
                        {
                            // 从Data字段获取物料数据（大写）
                            string materialJson = JsonConvert.SerializeObject(response.Data);
                            material = JsonConvert.DeserializeObject<Materialgroupmodel>(materialJson);
                            Console.WriteLine($"从API响应的Data字段成功解析物料数据，名称={material?.Materialgroupname}");
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"从API响应格式解析失败: {ex.Message}");
                    }
                }
                
                // 尝试方式3：使用JObject解析
                if (material == null)
                {
                    try
                    {
                        JObject jObj = JObject.Parse(result);
                        material = new Materialgroupmodel();
                        
                        // 尝试直接从根节点解析字段
                        if (jObj["Id"] != null || jObj["id"] != null)
                        {
                            try { material.Id = jObj.Value<long>(jObj["Id"] != null ? "Id" : "id"); } catch { }
                            try { material.Materialgroupcode = jObj.Value<string>("Materialgroupcode"); } catch { }
                            try { material.Materialgroupname = jObj.Value<string>("Materialgroupname"); } catch { }
                            try { material.Materialgrouptype = jObj.Value<string>("Materialgrouptype"); } catch { }
                            try { material.Operationalpathid = jObj.Value<string>("Operationalpathid"); } catch { }
                            try { material.Materialgroupdescribe = jObj.Value<string>("Materialgroupdescribe"); } catch { }
                            try { material.CreatedBy = jObj.Value<string>("CreatedBy"); } catch { }
                            try { material.CreatedTime = jObj.Value<DateTime>("CreatedTime"); } catch { }
                            try { material.UpdatedBy = jObj.Value<string>("UpdatedBy"); } catch { }
                            try { material.UpdatedTime = jObj.Value<DateTime>("UpdatedTime"); } catch { }
                        }
                        // 尝试从data/Data字段解析
                        else if (jObj["data"] != null || jObj["Data"] != null)
                        {
                            JToken dataNode = jObj["data"] ?? jObj["Data"];
                            try { material.Id = dataNode.Value<long>("Id"); } catch { }
                            try { material.Materialgroupcode = dataNode.Value<string>("Materialgroupcode"); } catch { }
                            try { material.Materialgroupname = dataNode.Value<string>("Materialgroupname"); } catch { }
                            try { material.Materialgrouptype = dataNode.Value<string>("Materialgrouptype"); } catch { }
                            try { material.Operationalpathid = dataNode.Value<string>("Operationalpathid"); } catch { }
                            try { material.Materialgroupdescribe = dataNode.Value<string>("Materialgroupdescribe"); } catch { }
                            try { material.CreatedBy = dataNode.Value<string>("CreatedBy"); } catch { }
                            try { material.CreatedTime = dataNode.Value<DateTime>("CreatedTime"); } catch { }
                            try { material.UpdatedBy = dataNode.Value<string>("UpdatedBy"); } catch { }
                            try { material.UpdatedTime = dataNode.Value<DateTime>("UpdatedTime"); } catch { }
                        }
                        
                        // 检查是否解析成功
                        if (material.Id > 0 || !string.IsNullOrEmpty(material.Materialgroupcode))
                        {
                            Console.WriteLine($"通过JObject解析成功，编码={material.Materialgroupcode}");
                        }
                        else
                        {
                            material = null; // 重置为null以尝试其他方式
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"JObject解析失败: {ex.Message}");
                    }
                }
                
                // 如果所有方法都失败，创建一个空对象并显示错误
                if (material == null)
                {
                    XtraMessageBox.Show("无法解析物料数据！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    isEdit = false;
                    return;
                }
                
                // 保存物料对象并显示数据
                originalMaterial = material;
                
                // 数据反填 - 使用空字符串代替null
                textEdit1.Text = originalMaterial.Materialgroupcode ?? string.Empty;
                textEdit2.Text = originalMaterial.Materialgroupname ?? string.Empty;
                
                // 设置物料类型下拉框
                int typeIndex = 0; // 默认为原材料
                switch (originalMaterial.Materialgrouptype)
                {
                    case "原材料": typeIndex = 0; break;
                    case "半成品": typeIndex = 1; break;
                    case "成品": typeIndex = 2; break;
                    case "工具": typeIndex = 3; break;
                    case "其他": typeIndex = 4; break;
                }
                comboBox1.SelectedIndex = typeIndex;
                
                // 更新工艺路线的可见性
                UpdatePathidVisibility();
                
                // 处理工艺路线
                if (!string.IsNullOrEmpty(originalMaterial.Operationalpathid) && 
                    originalMaterial.Operationalpathid != "-" && 
                    comboBoxPathid.Visible)
                {
                    int pathIndex = comboBoxPathid.FindString(originalMaterial.Operationalpathid);
                    if (pathIndex >= 0)
                        comboBoxPathid.SelectedIndex = pathIndex;
                }
                
                // 设置描述信息
                memoEdit1.Text = originalMaterial.Materialgroupdescribe ?? string.Empty;
                Console.WriteLine("数据反填完成");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"加载数据出错: {ex.Message}");
                XtraMessageBox.Show($"加载数据出错：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                isEdit = false;
            }
        }

        /// <summary>
        /// 保存成功后更新序号
        /// </summary>
        private void UpdateSequenceAfterSuccess()
        {
            // 只有在新增模式下成功保存后才更新序号
            if (isEdit)
                return;
                
            try
            {
                // 获取当前日期
                string today = DateTime.Now.ToString(dateFormat);
                int currentSequence = 1;
                
                // 读取当前序号
                if (File.Exists(sequenceFilePath))
                {
                    string[] fileContent = File.ReadAllLines(sequenceFilePath);
                    if (fileContent.Length >= 2)
                    {
                        string lastDate = fileContent[0];
                        int.TryParse(fileContent[1], out currentSequence);
                        
                        // 如果是新的一天，重置序号为1
                        if (lastDate != today)
                        {
                            currentSequence = 1;
                        }
                        else
                        {
                            // 否则序号加1
                            currentSequence++;
                        }
                    }
                }
                
                // 保存更新后的序号到文件
                using (StreamWriter writer = new StreamWriter(sequenceFilePath, false))
                {
                    writer.WriteLine(today);
                    writer.WriteLine(currentSequence.ToString());
                }
            }
            catch (Exception ex)
            {
                // 更新序号失败不影响主流程，可以静默处理
                Console.WriteLine($"更新序号失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void button2_Click(object sender, EventArgs e)
        {
            // 验证输入
            if (string.IsNullOrWhiteSpace(textEdit1.Text))
            {
                XtraMessageBox.Show("物料编码不能为空！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            if (string.IsNullOrWhiteSpace(textEdit2.Text))
            {
                XtraMessageBox.Show("物料名称不能为空！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            try
            {
                // 准备数据
                Materialgroupmodel model = new Materialgroupmodel
                {
                    Materialgroupcode = textEdit1.Text.Trim(),
                    Materialgroupname = textEdit2.Text.Trim(),
                    Materialgrouptype = comboBox1.SelectedItem?.ToString() ?? "原材料",
                    Materialgroupdescribe = memoEdit1.Text.Trim(),
                };

                // 设置默认工艺路线
                string selectedType = comboBox1.SelectedItem?.ToString();
                if (selectedType == "成品" || selectedType == "半成品")
                {
                    model.Operationalpathid = comboBoxPathid.SelectedItem?.ToString() ?? "-";
                }
                else
                {
                    model.Operationalpathid = "-";
                }

                // 如果是编辑模式
                if (isEdit && materialId.HasValue && materialId.Value > 0)
                {
                    model.Id = materialId.Value;
                    Console.WriteLine($"修改模式: ID={model.Id}");
                    
                    // 如果有原始物料数据，保留原有的创建人和创建时间
                    if (originalMaterial != null)
                    {
                        model.CreatedBy = originalMaterial.CreatedBy;
                        model.CreatedTime = originalMaterial.CreatedTime;
                        
                        // 记录原始数据信息用于调试
                        Console.WriteLine($"原始物料信息: 创建人={originalMaterial.CreatedBy}, 创建时间={originalMaterial.CreatedTime}");
                    }
                    else
                    {
                        // 如果没有原始数据，设置默认创建信息
                        model.CreatedBy = "admin";
                        model.CreatedTime = DateTime.Now;
                        Console.WriteLine("警告：原始物料信息为空，使用默认创建信息");
                    }
                    
                    // 设置修改人为"张三"，修改时间为当前时间
                    model.UpdatedBy = "张三";
                    model.UpdatedTime = DateTime.Now;
                    
                    // 确保ID字段正确设置
                    Console.WriteLine($"准备修改物料，ID={model.Id}, 编码={model.Materialgroupcode}, 名称={model.Materialgroupname}");
                }
                // 如果是新增模式
                else
                {
                    Console.WriteLine("新增模式");
                    // 设置创建信息
                    model.CreatedBy = "admin";
                    model.CreatedTime = DateTime.Now;
                    model.UpdatedBy = "admin"; // 新增时，修改人也是创建人
                    model.UpdatedTime = DateTime.Now;
                    
                    // 确保ID为0（新增时不需要ID）
                    model.Id = 0;
                }

                // 转换为JSON
                string jsonData = JsonConvert.SerializeObject(model);
                Console.WriteLine($"请求数据: {jsonData}");
                
                // 确定API路径
                string url = isEdit ? "/api/Materialgroup/UpdateMaterialgroup" : "/api/Materialgroup/AddMaterialgroup";
                Console.WriteLine($"请求API: {url}");

                // 使用 HttpClientHelper 发送请求
                string result = await HttpClientHelper.RequestUrl(RequestType.Post, url, jsonData);
                Console.WriteLine($"API返回结果: {result}");
                
                if (!string.IsNullOrEmpty(result))
                {
                    // 检查返回结果是否包含成功信息
                    bool isSuccess = true;
                    
                    try
                    {
                        // 尝试解析API返回结果
                        dynamic response = JsonConvert.DeserializeObject<dynamic>(result);
                        if (response != null && 
                            ((response.code != null && response.code.ToString() != "200") || 
                             (response.Code != null && response.Code.ToString() != "200")))
                        {
                            isSuccess = false;
                            string message = response.message ?? response.Message ?? "未知错误";
                            XtraMessageBox.Show($"操作失败：{message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    catch
                    {
                        // 解析失败，仍然继续（可能API返回非标准格式）
                    }
                    
                    if (isSuccess)
                    {
                        // 保存成功后更新序号（仅在新增模式下）
                        if (!isEdit)
                        {
                            UpdateSequenceAfterSuccess();
                        }
                        
                        XtraMessageBox.Show(isEdit ? "修改成功！" : "添加成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        
                        // 关闭窗体并返回
                        DialogResult = DialogResult.OK;
                        this.Close();
                    }
                }
                else
                {
                    XtraMessageBox.Show(isEdit ? "修改失败！" : "添加失败！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"保存操作发生异常: {ex.Message}\n{ex.StackTrace}");
                XtraMessageBox.Show($"操作失败：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 重置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            // 只有在新增模式下才需要重新生成编码
            if (!isEdit)
            {
                GenerateAutoIncrementCode();
            }
            
            // 清空其他输入框
            textEdit2.Text = string.Empty; // 物料名称
            memoEdit1.Text = string.Empty; // 描述
            
            // 重置下拉框
            comboBox1.SelectedIndex = 0;
            UpdatePathidVisibility();
        }
    }
}